package com.artisan.springuitls.demos;

import org.springframework.stereotype.Component;
import org.springframework.util.NumberUtils;

/**
 * NumberUtils 工具类演示
 * 功能：数字转换安全卫士
 * 优势：parseNumber() 安全转换字符串到数字，避免 NumberFormatException
 */
@Component
public class NumberUtilsDemo {

    /**
     * 场景：请求参数转整数
     */
    public Integer safeParseInt(String numStr) {
        System.out.println("\n========== NumberUtils Demo ==========");
        
        try {
            // ✅ 安全转换：失败抛异常
            Integer result = NumberUtils.parseNumber(numStr, Integer.class);
            System.out.println("✓ 解析 '" + numStr + "' => " + result);
            return result;
        } catch (IllegalArgumentException e) {
            System.out.println("✗ 解析失败 '" + numStr + "': " + e.getMessage());
            return null;
        }
    }

    /**
     * 演示各种数字类型转换
     */
    public void demonstrateNumberParsing() {
        System.out.println("\n--- 各种数字类型转换 ---");
        
        // 1. 转换为 Integer
        Integer intValue = NumberUtils.parseNumber("12345", Integer.class);
        System.out.println("✓ Integer: " + intValue);
        
        // 2. 转换为 Long
        Long longValue = NumberUtils.parseNumber("9876543210", Long.class);
        System.out.println("✓ Long: " + longValue);
        
        // 3. 转换为 Double
        Double doubleValue = NumberUtils.parseNumber("123.45", Double.class);
        System.out.println("✓ Double: " + doubleValue);
        
        // 4. 转换为 Float
        Float floatValue = NumberUtils.parseNumber("67.89", Float.class);
        System.out.println("✓ Float: " + floatValue);
        
        // 5. 转换为 Short
        Short shortValue = NumberUtils.parseNumber("128", Short.class);
        System.out.println("✓ Short: " + shortValue);
        
        // 6. 转换为 Byte
        Byte byteValue = NumberUtils.parseNumber("127", Byte.class);
        System.out.println("✓ Byte: " + byteValue);
        
        System.out.println();
    }

    /**
     * 演示不同进制解析
     */
    public void demonstrateDifferentRadix() {
        System.out.println("\n--- 不同进制解析 ---");
        
        // 十六进制
        String hexStr = "0xFF";
        try {
            Integer hexValue = NumberUtils.parseNumber(hexStr, Integer.class);
            System.out.println("✓ 十六进制 " + hexStr + " => " + hexValue);
        } catch (IllegalArgumentException e) {
            // NumberUtils 不直接支持进制前缀，需要先转换
            Integer hexValue = Integer.decode(hexStr);
            System.out.println("✓ 十六进制 " + hexStr + " => " + hexValue + " (使用 Integer.decode())");
        }
        
        // 八进制
        String octStr = "0755";
        Integer octValue = Integer.decode(octStr);
        System.out.println("✓ 八进制 " + octStr + " => " + octValue + " (使用 Integer.decode())");
        
        System.out.println();
    }

    /**
     * 演示错误处理
     */
    public void demonstrateErrorHandling() {
        System.out.println("\n--- 错误处理 ---");
        
        String[] invalidInputs = {
            "abc",
            "123.45.67",
            "",
            "  ",
            "12345678901234567890123456789",  // 超出范围
            null
        };
        
        for (String input : invalidInputs) {
            try {
                Integer result = NumberUtils.parseNumber(input, Integer.class);
                System.out.println("✓ '" + input + "' => " + result);
            } catch (Exception e) {
                System.out.println("✗ '" + input + "' => 解析失败: " + e.getClass().getSimpleName());
            }
        }
        
        System.out.println();
    }

    /**
     * 演示数字格式化
     */
    public void demonstrateNumberFormatting() {
        System.out.println("\n--- 数字格式化 ---");
        
        // NumberUtils 主要用于解析，格式化使用 NumberFormat
        System.out.println("✓ NumberUtils 不提供格式化功能");
        System.out.println("✓ 推荐使用：");
        System.out.println("  - DecimalFormat: new DecimalFormat(\"#,###.00\").format(12345.6)");
        System.out.println("  - String.format: String.format(\"%.2f\", 12345.6)");
        System.out.println("  - NumberFormat: NumberFormat.getCurrencyInstance().format(12345.6)");
        
        System.out.println();
    }

    /**
     * 实际应用场景：HTTP 请求参数解析
     */
    public void demonstrateHttpParameterParsing() {
        System.out.println("\n--- HTTP 请求参数解析场景 ---");
        
        // 模拟请求参数
        String pageParam = "1";
        String sizeParam = "20";
        String priceParam = "99.99";
        String invalidParam = "abc";
        
        System.out.println("✓ 解析请求参数:");
        
        // 页码
        Integer page = safeParseInteger(pageParam, 1);
        System.out.println("  - page: " + page);
        
        // 每页大小
        Integer size = safeParseInteger(sizeParam, 10);
        System.out.println("  - size: " + size);
        
        // 价格
        Double price = safeParseDouble(priceParam, 0.0);
        System.out.println("  - price: " + price);
        
        // 无效参数（使用默认值）
        Integer invalid = safeParseInteger(invalidParam, 0);
        System.out.println("  - invalid: " + invalid + " (使用默认值)");
        
        System.out.println();
    }

    /**
     * 实际应用场景：配置文件数值解析
     */
    public void demonstrateConfigParsing() {
        System.out.println("\n--- 配置文件数值解析场景 ---");
        
        // 模拟配置值（可能是字符串）
        String maxConnections = "100";
        String timeout = "30000";
        String retryCount = "3";
        String cacheSize = "1024";
        
        System.out.println("✓ 解析配置值:");
        System.out.println("  - maxConnections: " + 
            NumberUtils.parseNumber(maxConnections, Integer.class));
        System.out.println("  - timeout: " + 
            NumberUtils.parseNumber(timeout, Long.class) + " ms");
        System.out.println("  - retryCount: " + 
            NumberUtils.parseNumber(retryCount, Integer.class));
        System.out.println("  - cacheSize: " + 
            NumberUtils.parseNumber(cacheSize, Integer.class) + " MB");
        
        System.out.println();
    }

    /**
     * 与 Java 原生方法对比
     */
    public void compareWithNativeMethods() {
        System.out.println("\n--- 与 Java 原生方法对比 ---");
        
        String numStr = "123";
        
        System.out.println("✓ Java 原生:");
        System.out.println("  - Integer.parseInt(\"123\") => " + Integer.parseInt(numStr));
        System.out.println("  - 缺点：不支持其他数字类型，需要多个方法");
        System.out.println("");
        System.out.println("✓ Spring NumberUtils:");
        System.out.println("  - NumberUtils.parseNumber(\"123\", Integer.class) => " + 
            NumberUtils.parseNumber(numStr, Integer.class));
        System.out.println("  - 优点：统一 API，支持所有数字类型");
        System.out.println("");
        System.out.println("✓ 推荐使用场景:");
        System.out.println("  - 简单场景：Integer.parseInt()");
        System.out.println("  - 需要泛型：NumberUtils.parseNumber()");
        System.out.println("  - 动态类型：NumberUtils.parseNumber(str, targetClass)");
        
        System.out.println();
    }

    /**
     * 数字类型转换
     */
    public void demonstrateNumberConversion() {
        System.out.println("\n--- 数字类型转换 ---");
        
        // 不同数字类型之间的转换
        Number number = 123.45;
        
        // 转换为 Integer
        Integer intValue = NumberUtils.convertNumberToTargetClass(number, Integer.class);
        System.out.println("✓ 123.45 => Integer: " + intValue); // 123
        
        // 转换为 Long
        Long longValue = NumberUtils.convertNumberToTargetClass(number, Long.class);
        System.out.println("✓ 123.45 => Long: " + longValue); // 123
        
        // 转换为 Double
        Double doubleValue = NumberUtils.convertNumberToTargetClass(number, Double.class);
        System.out.println("✓ 123.45 => Double: " + doubleValue); // 123.45
        
        System.out.println("==========================================\n");
    }

    /**
     * 辅助方法：安全解析 Integer
     */
    private Integer safeParseInteger(String str, Integer defaultValue) {
        try {
            return NumberUtils.parseNumber(str, Integer.class);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 辅助方法：安全解析 Double
     */
    private Double safeParseDouble(String str, Double defaultValue) {
        try {
            return NumberUtils.parseNumber(str, Double.class);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 最佳实践
     */
    public void printBestPractices() {
        System.out.println("\n========== 最佳实践 ==========");
        System.out.println("✓ 1. 统一使用 parseNumber() 处理数字转换");
        System.out.println("✓ 2. 始终 try-catch 捕获异常或提供默认值");
        System.out.println("✓ 3. HTTP 参数解析时使用此工具");
        System.out.println("✓ 4. 配置文件数值解析时使用");
        System.out.println("✓ 5. 使用 convertNumberToTargetClass() 转换数字类型");
        System.out.println("✓ 6. 简单场景可直接用 Integer.parseInt()");
        System.out.println("==========================================\n");
    }
}

